﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using PSE.ProcessManager.Entity.Enums;

namespace ConfigurationManager.Model
{
    public class Process
    {
        public int Id
        {
            get;
            set;
        }

        public InteligenceModule InteligenceModule
        {
            get;
            set;
        }

        public string Name
        {
            get;
            set;
        }

        public bool IsActive
        {
            get;
            set;
        }

        public string Description
        {
            get;
            set;
        }
        public InstanceContext? InstanceContext
        {
            get;
            set;
        }
        public string Class
        {
            get;
            set;
        }
        public string Assembly
        {
            get;
            set;
        }
        //public FailureActions FirstFailureRecovery
        //{
        //    get;
        //    set;
        //}
        //public FailureActions SecondFailureRecovery
        //{
        //    get;
        //    set;
        //}
        //public FailureActions SubsequentFailuresRecovery
        //{
        //    get;
        //    set;
        //}
        public FailureActions FailureRecovery 
        { 
            get; 
            set; 
        }
        public StartUpType? InitializationType
        {
            get;
            set;
        }
        public Instance Instance
        {
            get;
            set;
        }

        public string InstanceName
        {
            get
            {
                return this.Instance.Name;
            }
        }

        public string ProductName
        {
            get
            {
                return this.Instance.Product.Name;
            }
        }

        public string InteligenceModuleName
        {
            get
            {
                return this.InteligenceModule.Name;
            }
        }

        public Process()
        {
            this.Instance = new Instance();
            this.InteligenceModule = new InteligenceModule();
        }

        #region Métodos
        public static List<Process> Retrieve()
        {
            DataAccess.Process p = new DataAccess.Process();
            return p.Retrieve();
        }

        public static List<Process> RetrieveByInstance(int instanceId)
        {
            DataAccess.Process p = new DataAccess.Process();
            return p.RetrieveByInstance(instanceId);
        }

        public static List<Process> RetrieveByInstance(int instanceId, bool? isActive)
        {
            DataAccess.Process p = new DataAccess.Process();
            return p.RetrieveByInstance(instanceId, isActive);
        }

        public static void Save(Process process)
        {
            if (process.Instance.Product.Id <= 0)
                throw new ValidationException("O produto deve ser informado.");

            if (process.Instance.Id <= 0)
                throw new ValidationException("A instância deve ser informada.");

            if (string.IsNullOrEmpty(process.Name))
                throw new ValidationException("O nome do processo deve ser informado.");
            else if (process.Name.Length > 100)
                throw new ValidationException("O nome do processo deve ter no máximo 100 caracteres.");

            if (string.IsNullOrEmpty(process.Description))
                throw new ValidationException("A descrição do processo deve ser informada.");
            else if (process.Description.Length > 120)
                throw new ValidationException("A descrição do processo deve ter no máximo 120 caracteres.");

            if (process.InteligenceModule.Id <= 0)
                throw new ValidationException("O inteligence module deve ser informado.");

            if (string.IsNullOrEmpty(process.Assembly))
                throw new ValidationException("O assembly deve ser informado.");
            else if (process.Assembly.Length > 250)
                throw new ValidationException("O nome do assembly deve ter no máximo 250 caracteres.");

            if (string.IsNullOrEmpty(process.Class))
                throw new ValidationException("A classe deve ser informada.");
            else if (process.Class.Length > 250)
                throw new ValidationException("O nome da classe deve ter no máximo 250 caracteres.");

            if (!process.InitializationType.HasValue)
                throw new ValidationException("O tipo de inicialização deve ser informado.");

            if (!process.InstanceContext.HasValue)
                throw new ValidationException("O tipo de instância deve ser informado.");

            DataAccess.Process p = new DataAccess.Process();
            p.Save(process);
        }

        public static void Delete(int processId, int productId)
        {
            DataAccess.Process p = new DataAccess.Process();
            p.Delete(processId, productId);
        }
        #endregion


    }
}
